Agent Architecture: An Overview

Introduction The advancement of the Internet technology has increased the need for distributed, concurrent, heterogeneous and dynamic application systems. Agent technology is a new paradigm suitable for developing such systems that situates and operates in a dynamic and heterogeneous environment. What exactly is an agent? To date, there is no widely accepted definition of what an agent is. In this study, an agent is referred to as an autonomous software entity that is situated in some environment where it can monitor and response to changes proactively or reactively by itself or through communication with other agents to persistently achieve certain goal/task on behalf of user or other agents (Wooldridge, 2009). An agent possesses certain distinct characteristics such as (Wooldridge & Jennings, 1995).  Autonomous: the ability to operate without the direct intervention of human and control over its internal state.  Social: the ability to interact with human and other agents.  Reactive: the ability to perceive changes in the environment and response to it in a timely fashion.  Proactive: the ability to show goal directed behavior. Other characteristics that an agent might have include mobility, benevolent, trustworthiness, rationality, and learning capability. Mobility is the ability to travel between different hosts in a computer network. Benevolent is the characteristic agent will always perform what it is asked to do. TRANSACTIONS ON SCIENCE AND TECHNOLOGY 2014. Vol. 1, No 1, pp 18-35 DECEMBER 2014 /19 Trustworthiness is the characteristic agent will not deliberately communicate false information. Rationality is the characteristic agent will always never to prevent its goals being achieved. Learning capability is the ability to adapt itself to fit its environment and to the desires of its users. In a complex system, an agent may not exist alone in an environment as they may be multiple agents that are situated in the same environment. Multi-agent system is the study of systems that are made up of multiple heterogeneous software entity (agents) that interact with each other (Wei B, 1999; Shoham & Leyton-Brown, 2008). In a multi-agent system environment, agents may have common or conflicting goal to be achieved (Yu et al., 2010; Durfee & Rosenschein, 1994). The interaction between agents can happen directly or indirectly. Direct communication is achieved through channel such as message passing whilst indirect communication is achieved through affecting the environment and sense by other agents (Genesereth & Ketchpel, 1994; Maes, 1997). Normally, agents that have common goal in a multi-agent system will cooperate in order to achieve the goal (Doran et al., 1997; Pozna et al., 2011). In the case of agents with conflicting goals, the agents will compete against each other to obtain resources for personal goal attainment (Leyton-Brown , 2003). In order for agents to cooperate and coordinate in achieving their goals, agents need to reason about when and what to do under certain circumstances. The foundation of the agent reasoning mechanism lies in the component called agent architecture. Agent architecture is the blueprint for building an agent just like a class in objectoriented programming. Wooldridge referred to agent architecture as software architecture that is intended to support decision making process (Wooldridge, 2001). Maes described agent architecture as architecture that encompasses techniques and algorithms to support decomposing set of components and how these components interact (Maes, 1991). Agent architecture is the building block for creating an agent much like creating an object in a class. The agent architecture is the brain of the agent as it determines how the knowledge/information is represented in the agent. It also determines the action the agent should take based on its underlying reasoning/interpretation mechanism. Thus, different architectures used different representation approaches for their reasoning mechanism to solve a variety of problems. These architectures can be broadly categorized into three groups, the classical architecture, the cognitive architecture and the semantic agent architecture. The classical architectures include logic-based architecture, reactive architecture, BDI architecture, and hybrid architecture. The logic-based architecture is an agent architecture that uses symbolic representation for reasoning. The reactive agent architecture is a direct stimulus-response agent architecture. On the other hand, the BDI architecture is a deliberative agent architecture based on mental states characteristic such as belief, desire, and intention. The layered architecture is the hybrid of reactive and deliberative agent architecture. The cognitive architecture is based on cognitive sciences and the semantic agent architecture utilizes semantic technology. TRANSACTIONS ON SCIENCE AND TECHNOLOGY 2014. Vol. 1, No 1, pp 18-35 DECEMBER 2014 /20 The remainder of this paper describes the various agent architectures that can be used to build agent and multi-agent system. Section 2 discusses the logic-based architecture. The reactive agent and BDI architecture are discussed in Section 3 and 4 respectively. Section 5 describes the layered architectures whilst Sections 6 and 7 present an overview of cognitive architecture and semantic agent architecture. Finally, we conclude our discussed on agent architectures in Section 8. Logic-Based Architecture Logic-based architecture also known as the symbolic-based or deliberative architecture is one the earliest agent architecture that rests on the physical-symbol systems hypothesis (Newell & Simon, 1976). This classical architecture is based on the traditional artificial symbolic approach by representing and modeling the environment and the agent behavior with symbolic representation. Thus, the agent behavior is based on the manipulation of the symbolic representation. Agent’s role in this classical architecture may also be considered as theorem provers (Shardlow, 1990). The syntactical manipulation of the symbolic representation is the process of logical deduction or theorem proving. As an instance of theorem proving, the agent specifications outlines how the agent behaves, how the goals are generated and what action the agent can take to satisfy these goals. An example of logic-based architecture formalism is as follows:  Assume that the environment is described by sentences in L and the knowledge base that contains all the information regarding the environment KB = P(L) where P(L) is the set of possible environments.  For each moment of the time t, an agent’s internal state is represented by KB = {KB1, KB2, KB3... KBn} where KBi KB.  The possible environment states are represented by S = {s1, s2, ...}.  An agent's reasoning mechanism is modeled by a set of deduction rules, p which are the rules of inference.  An agent perception functions as see:S ->P.  The agent’s internal state is updated by a perception function where next:KB × P ->KB.  Thus, agent can choose an action from a set A = {a1, a2, ...}, action:KB ->A which is defined in terms of deduction rules. The outcome of an agent’s actions is drawn via the function do where do:A × S ->S.  The decision making process is modeled through the rules of inference p, if a do:A can be derived, the A is returned as an action to be best performed, else if do:A cannot be derived, a special null action is returned. Vacuum cleaning example in (Russell & Norvig, 1995) illustrates the idea of logic-based architecture based on the specification above. The programmer has to encode the inference rules p in a way that enables the agent to decide what to do. Examples of this kind of classical agent architecture TRANSACTIONS ON SCIENCE AND TECHNOLOGY 2014. Vol. 1, No 1, pp 18-35 DECEMBER 2014 /21 approach include classical planning agent such as STRIPS (Fikes & Nilsson, 1971), IPEM (AmbrosIngerson & Steel, 1988), Autodrive (Wood, 1993), Softbots (Etzioni et al., 1994), Phoenix systems (Cohen et al., 1989), IRMA (Bratman et al., 1988), HOMER (Vere & Bickmore, 1990), and GRATE (Jennings, 1993). BDI architecture is also considered as the subset of logic-based architecture. However, due to its popularity and wide adoption of the architecture, the discussion on this particular architecture is detailed in Section 4. Although, the simplicity and elegance of logical semantics of the logic based architecture is attractive, there are several problems associated with this approach. Firstly, the transduction problem implies the problem of translating modeling into symbolic representation. It is difficult to translate and model the environment’s information into symbolic representation accurately for computation process especially complex environment. Secondly, it is also difficult to represent information in a symbolic form that is suitable for the agents to reason with and in a time constrained environment. Finally, the transformation of percepts input may not be accurate enough to describe the environment itself due to certain faults such as sensor error, reasoning error and etc. It is very difficult or sometimes impossible to put down all the rules for the situation that will be encountered by the agent in a complex environment since the deduction process is based on set of inference rules. The assumption in calculative rationality where the world does not change in a significant way while the agent is deliberating is not realistic. Assume that on time t1, agent tries to reason an optimal action for that particular time. However, the reasoning result may only be available at time t2 where the environment has already changed so much so that the optimal action for time t1 may not be an optimal action for time t2. Thus, due to the computational complexity of theorem proving over this approach, it is not appropriate for time constrained domain. Building agent in logic-based approach is viewed as a deduction process. An agent is encoded as a logical theory by using specification and the process of selecting the action is through deduction process that reduces the problem to a solution such as in theorem proving. An improvement version logic based approach has been carried out in (Amir & Maynard-Reid, 2004; Amir & Maynard-Reid, 2000). In (Amir & Maynard-Reid, 2004) a logic-based AI architecture is implemented on Brooks' Subsumption architecture. In the implementation of this architecture, different layers of control is axiomatized in First-Order Logic (FOL), thus, independent theorem provers are used to derive each layer's output given its input. This architecture proved the versatility of the theorem provers which allow them to realize complex tasks, while keeping individual theories simple (Amir & MaynardReid, 2000). Reactive Architecture Reactive agent architecture is based on the direct mapping of situation to action. It is different from the logic-based architecture where no central symbolic world model and complex symbolic reasoning are used. Agent responses to changes in the environment in a stimulus-response based. The reactive TRANSACTIONS ON SCIENCE AND TECHNOLOGY 2014. Vol. 1, No 1, pp 18-35 DECEMBER 2014 /22 architecture is realized through a set of sensors and effectors, where perceptual input is mapped to the effectors to changes in the environment. Brook's subsumption architecture is known as the best pure reactive architecture (Brooks, 1986). This architecture was developed by Brook who has critiqued on many of the drawbacks in logic-based architecture. Figure 1 illustrates an example of reactive architecture. The figure shows that each of the percept situation is mapped into an action which specifically responses to the percept situation. Figure 1: Reactive Architecture The key idea of subsumption architecture is that intelligent behaviour can be generated without explicit representations and abstract reasoning with symbolic AI technique (Brooks, 1991a; Brooks, 1991b). Intelligence is an emergent property of certain complex systems. Subsumption architecture is implemented in finite state machines with different layers connected to sensors that perceive the environment changes and map the action to be performed (Brooks, 1986). A set of taskaccomplishing behaviour are used in the decision making process. Each of the behaviour can be thought of as an individual function which maps changes in the environment with an action. Multiple behaviours that can be fired simultaneously is another characteristic of subsumption architecture. The subsumption architecture hierarchical structure represents different behaviours. The lowest layer in the hierarchy has the highest priority. Higher layer represent more abstract behaviour than the lower layer in the hierarchy. Complex behaviour is achieved through the combination of these behaviours. Figure 2 shows action selection in the layered architecture. In this layered architecture, the lower the layer the higher the priority. The lower layer will be the primitive behaviour and higher layer will represent a more abstract behaviour. Prece pt 1 Actio n 1 Prece pt 2 Actio n 2 Prece pt 3 Actio n 3 Prece pt 4 Actio n 4 Environment Perception Mapping TRANSACTIONS ON SCIENCE AND TECHNOLOGY 2014. Vol. 1, No 1, pp 18-35 DECEMBER 2014 /23 Figure 2: Action Selections in Layered Architecture The subsumption architecture is implemented in Steel’s study (Steels, 1990) for the mission to a distant planet to collect sample of rocks and minerals. A near-optimal performance can be obtained through simple adjustment and the solution is cheap in computing power and it is also robust. Chapman came up with similar approach to Brook’s work in (Chapman & Agre, 1986) and is referred to as the new abstract reasoning. This approach is used in the celebrated PENGI system which simulated a computer game with central character control that can accomplish routine work with little variation (Agre & Chapman, 1987). Figure 3 shows a Pengo game in progress (Agre & Chapman, 1987).PENGI is a program written to play an arcade game called Pengo which is made up of a 2-Dmaze with unit-sized ice blocks. In this game, PENGI is programmed to move the Penguin in the game to avoid the bees attack and block slide to survive. Figure 3: Pengo Game in Progress Layer 3